BowtiedFox - Surviving Ai Notes

The traditional wealth path — get a high-paying job, start a business, invest profits — still works, but AI has raised the bar for everyone. Easy tasks are being automated, junior roles are shrinking, and competition is fierce because AI tutoring lets anyone learn faster.

To win, you can’t just follow the rules; wealth comes from ownership, arbitrage, and moving quickly when big changes (like AI) happen. Many “AI tools” are just ChatGPT with a nicer interface, and most people don’t know how it works — that’s your opportunity.

Two best career paths now: Sales: Still valuable for building trust in big purchases, now boosted by AI tools. Programming: Costs to build software are lower than ever, and software scales infinitely. Pick the one you enjoy, build skills, and use them to eventually own your own product or company. Move fast before the market catches up.

AI is automating low-skill coding work, but strong programmers are still needed to review AI’s output, prevent bugs, handle complex tradeoffs, and ensure companies avoid legal issues. Specializing in a niche and building high-level skills is key

FAANG jobs are worth aiming for because they offer huge salaries, flexible career options, prestige, world-class learning environments, and elite networks that open doors for future roles or funding. Competition is tough, but the rewards are life-changing.

Big tech interviews are highly standardized and focus almost entirely on algorithm problem-solving, not degrees or flashy projects. Startups care more about practical skills and personal fit, while non-tech companies have easier interviews but lower pay.

The right way to prepare is by mastering algorithm patterns so you can instantly recognize the best approach in different scenarios, rather than memorizing hundreds of questions. This makes you adaptable to any twist.

These interviews also assess deeper traits: structured thinking, clear communication, collaboration, handling complexity, and staying calm under pressure. Building these abilities not only helps you get hired but also future-proofs your career from AI displacement.

BowtiedFox advice - At any moment, ask yourself: “What’s the best thing I could be doing right now?” If you don’t know, define the problem clearly, then either research it or ask someone more knowledgeable. It’s basically about clarity, discipline, and delayed gratification — applied not just in work but in everyday life.

You need math basics and programming fundamentals before learning algorithms. Suggested free courses (MIT OpenCourseWare):

• Introduction to Computer Science and Programming (6.0001)
• Mathematics for Computer Science (6.042J)
• Introduction to Algorithms (6.006)

Avoid “analysis paralysis” — don’t obsess over which book is best (CLRS, Skiena, etc.). Pick one, learn the basics, then practice. Core requirement: be able to write basic algorithms like binary search, DFS, BFS from scratch.

Practicing Algorithms

Best platform: LeetCode (problems sorted by topic, difficulty, and company). Problems get easier with practice — nobody is good at LeetCode from day one. Aim for:

• Easy: 10–15 min
• Medium: 20–30 min
• Hard: ~45 min (often a medium with extra restrictions)

Spend at least 1 hour before looking at solutions — build resilience.

Choosing Problems - Prefer questions with higher acceptance rates (usually clearer wording). Do company-specific tagged problems before interviews.

Problem-Solving Process

• Understand problem: inputs, outputs, constraints, edge cases.
• Recognize patterns: match to known problems.
• Plan solution before coding.
• Write code.
• Check correctness.
• Optimize if possible.

Priority order: Correct → Efficient → Clean.

Correctness - It’s easier to prove a solution wrong than right.

Use decision coverage: test every branch of logic.

Test for:

• Boundary cases (min/max, empty data, etc.)
• Test for: Uniform inputs (all same)
• Special values (negative, zero, even/odd, prime)
• Loop edge cases (zero/one/many iterations)
• Tiebreakers (equal values in sorting)

Even if you don’t write all test cases in code, mention them to the interviewer.

Efficiency

Big-O basics - Describes how runtime grows with input size (worst case focus).

Common complexities:

• O(1) Constant
• O(log N) Logarithmic
• O(N) Linear
• O(N log N) Log-linear
• O(N²) Quadratic
• O(N³) Cubic
• O(2ᴺ) Exponential

Optimization rules :

• Improve naive solution by at least one level (e.g., O(N³) → O(N²)).
• Identify bottlenecks (highest complexity step) first.
• Remove unnecessary work (reduce loops if possible).
• Avoid duplicate work (cache results / memoization).

Clean Code

• Use descriptive variable names.
• Apply DRY (Don’t Repeat Yourself) — use loops/functions for repeated logic.
• Use explaining variables to make code self-explanatory.
• Rewrite conditionals to read like natural language, avoid confusing negations.
• Remember: code is read more than it’s written — prioritize clarity for humans.

Use descriptive variable names.

Apply DRY — use loops/functions for repeated logic.